/**
 * 数组对象去重
 * @param {Object} person
 * @param {Object} key
 */
export function reduce(person, key) {
  const obj = {}
  person = person.reduce((cur, next) => {
    obj[next[key]] ? '' : obj[next[key]] = true && cur.push(next)
    return cur
  }, [])
  return person
}
export function extractKey(arr, key) {
  let str = ''
  if (!arr.length) return str
  arr.forEach(item => {
    str = str + item[key] + ','
  })
  str = str.substr(0, str.length - 1)
  return str
}
// 递归降维数组
export function flatten(arr) {
  return [].concat(...arr.map(x => Array.isArray(x) ? flatten(x) : x))
}

// 创建排序方法
export function sortByKey(array, key, order) {
  return array.sort(function(a, b) {
    var x = a[key]; var y = b[key]
    if (order) {
      return ((x < y) ? -1 : ((x > y) ? 1 : 0))
    } else {
      return ((x < y) ? ((x > y) ? 1 : 0) : -1)
    }
  })
}

/**
 * 班次数据解析
 * @param {*} item
 * @param {*} name
 * @param {*} color
 */
export function workParse(item, name = 'classNames', color = 'color') {
  if (item[name]) {
    const names = item[name].split(',')
    const colors = item[color] && item[color].split(',') || []
    const arr = []
    names.forEach((i, index) => {
      arr.push({ name: i, color: colors[index] })
    })
    return arr
  }
  return []
}

/**
 *  根据下标重新获取拖拽排序数组
 *  @param oldIndex 从下标拖拽
 *  @param newIndex 拖拽到的下标
 *  @param oldList 拖拽的数组
 *  @return [] 拖拽后的数组
 *  例如：
 *   1->3
 *  下标值 0 1 2 3 4 5
 *  原数组 a b c d e f
 *  新数组 a c d b e f
 *  newList[5] = oldList[5]
 *  newList[4] = oldList[4]
 *  newList[3] = oldList[1]
 *  newList[2] = oldList[3]
 *  newList[1] = oldList[2]
 *  newList[0] = oldList[0]
 *
 *  3->1
 *  下标值 0 1 2 3 4 5
 *  原数组 a b c d e f
 *  新数组 a d b c e f
 *  newList[5] = oldList[5]
 *  newList[4] = oldList[4]
 *  newList[3] = oldList[2]
 *  newList[2] = oldList[1]
 *  newList[1] = oldList[3]
 *  newList[0] = oldList[0]
 */
export function getOrderList(oldIndex, newIndex, oldList) {
  // 新数据集合
  const newList = []
  // 第一种情况 oldIndex < newIndex 1->3
  if (oldIndex < newIndex) {
    for (let i = 0; i < oldList.length; i++) {
      // 超过移动下标范围的 数据(小于第一个下标或者大于最后一个下标) 直接赋值
      if (i < oldIndex || i > newIndex) {
        newList[i] = oldList[i]
      } else {
        // 当前下标 小于 最后一个下标时
        if (i < newIndex) {
          // 取下标向后偏移1的数据
          newList[i] = oldList[i + 1]
          // 当前下标 等于 最后一个下标时
        } else {
          // 取第一个下标的数据
          newList[i] = oldList[oldIndex]
        }
      }
    }
    // 第二种情况 oldIndex > newIndex	 3->1
  } else if (oldIndex > newIndex) {
    for (let i = 0; i < oldList.length; i++) {
      // 超过移动下标范围的 数据(大于第一个下标或者小于最后一个下标) 直接赋值
      if (i > oldIndex || i < newIndex) {
        newList[i] = oldList[i]
      } else {
        // 当前下标 等于 最后一个下标时
        if (i === newIndex) {
          // 取第一个下标的数据
          newList[i] = oldList[oldIndex]
          // 当前下标 大于 最后一个下标时
        } else if (i > newIndex) {
          // 取下标向前偏移1的数据
          newList[i] = oldList[i - 1]
        }
      }
    }
    // 第三种情况    oldIndex = newIndex  1->1
  } else {
    for (let i = 0; i < oldList.length; i++) {
      // 直接赋值
      newList[i] = oldList[i]
    }
  }
  return newList
}

/**
 * 将数组根据字段名分组成ArrayMap
 * @param {Object} array
 * @param {Object} fieldName
 */
export function groupMapByFieldName(array, fieldName) {
  // ArrayMap对象
  const arrayMap = {}
  // 遍历数组
  if (array && array.length) {
    array.forEach(function(o) {
      // 字段值获取到的数据为空时 设置一个随机数
      if (o[fieldName] === '') {
        o[fieldName] = Math.random()
      }
      // 获取分组字段的值
      const group = JSON.stringify(o[fieldName])
      // map对象 对应字段值  获取或者创建数组
      arrayMap[group] = arrayMap[group] || []
      // 将当前的元素添加到数组中
      arrayMap[group].push(o)
    })
  }
  // 返回Map对象
  return arrayMap
}
/**
 * 将路由树转换path
 * @param {Object} routes
 */
export function route2PathArray(routes, arr, parent) {
  routes.forEach(route => {
    if (parent) {
      route.path = parent.path + '/' + route.path
    }
    if (route.children && route.children.length > 0) {
      route2PathArray(route.children, arr, route)
    }
    arr.push(route)
  })
}
